package com.admin_system.controller;


import com.admin_system.entity.DocProcessResponse;
import com.admin_system.service.impl.DocProcessServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.Map;

/**
 * REST API控制器，提供给外部程序调用的接口
 */
@RestController
@RequestMapping("/api")
@Slf4j
public class DocumentProcessController {

    @Autowired
    private DocProcessServiceImpl docProcessService;
    
    // 用于标记是否正在处理文档，保证只有一个用户可以进行处理操作
    private static volatile boolean isProcessing = false;
    
    /**
     * 服务健康检查
     */
    @GetMapping("/status")
    public ResponseEntity<Map<String, Object>> getStatus() {
        Map<String, Object> status = new HashMap<>();
        boolean pythonServiceAvailable = docProcessService.isServiceAvailable();
        
        status.put("javaService", "online");
        status.put("pythonService", pythonServiceAvailable ? "online" : "offline");
        status.put("status", pythonServiceAvailable ? "healthy" : "degraded");
        
        return ResponseEntity.ok(status);
    }
    
    /**
     * 处理文档API
     */
    @PostMapping("/process")
    public ResponseEntity<?> processDocument(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body(Map.of("error", "没有上传文件"));
        }
        
        if (!file.getOriginalFilename().endsWith(".doc") && !file.getOriginalFilename().endsWith(".docx")) {
            return ResponseEntity.badRequest().body(Map.of("error", "仅支持Word文档(.doc, .docx)"));
        }
        
        // A：检查是否有其他用户正在执行处理操作
        if (isProcessing) {
            log.warn("已有其他用户正在使用文档处理工具，请求被拒绝");
            Map<String, Object> response = new HashMap<>();
            response.put("status", "busy");
            response.put("error", "系统正在为其他用户处理文档，请稍后再试");
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(response);
        }
        
        try {
            // 检查Python服务是否可用
            if (!docProcessService.isServiceAvailable()) {
                return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
                        .body(Map.of("error", "Python处理服务当前不可用"));
            }
            
            // B：设置处理状态为正在处理
            isProcessing = true;
            
            // 调用Python服务处理文档
            DocProcessResponse response = docProcessService.processDocument(file);
            
            if (response.getError() != null) {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                        .body(Map.of("error", response.getError()));
            }
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("处理文档API错误", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Map.of("error", "处理文档时发生错误: " + e.getMessage()));
        } finally {
            // C：无论成功还是失败，都需要重置处理状态
            isProcessing = false;
            log.info("文档处理操作完成，重置处理状态");
        }
    }
    
    /**
     * 直接下载处理后的文件（一步完成）
     */
    @PostMapping("/process-and-download")
    public ResponseEntity<?> processAndDownload(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body(Map.of("error", "没有上传文件"));
        }
        
        if (!file.getOriginalFilename().endsWith(".doc") && !file.getOriginalFilename().endsWith(".docx")) {
            return ResponseEntity.badRequest().body(Map.of("error", "仅支持Word文档(.doc, .docx)"));
        }
        
        // 检查是否有其他用户正在执行处理操作
        if (isProcessing) {
            log.warn("已有其他用户正在使用文档处理工具，请求被拒绝");
            Map<String, Object> response = new HashMap<>();
            response.put("status", "busy");
            response.put("error", "系统正在为其他用户处理文档，请稍后再试");
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(response);
        }
        
        try {
            // 检查Python服务是否可用
            if (!docProcessService.isServiceAvailable()) {
                return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
                        .body(Map.of("error", "Python处理服务当前不可用"));
            }
            
            // 设置处理状态为正在处理
            isProcessing = true;
            
            // 调用Python服务处理文档
            DocProcessResponse response = docProcessService.processDocument(file);
            
            if (response.getError() != null) {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                        .body(Map.of("error", response.getError()));
            }
            
            // 从Python服务下载处理后的文件
            File processedFile = docProcessService.downloadProcessedDocument(response.getDownloadUrl());
            
            ByteArrayResource resource = new ByteArrayResource(Files.readAllBytes(processedFile.toPath()));
            
            HttpHeaders headers = new HttpHeaders();
            headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + response.getFilename());
            
            return ResponseEntity.ok()
                    .headers(headers)
                    .contentLength(processedFile.length())
                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
                    .body(resource);
            
        } catch (IOException e) {
            log.error("处理并下载文档时发生错误", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Map.of("error", "处理并下载文档时发生错误: " + e.getMessage()));
        } finally {
            // 无论成功还是失败，都需要重置处理状态
            isProcessing = false;
            log.info("文档处理操作完成，重置处理状态");
        }
    }
} 